home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / standards / sgml / nist / parse3 / diutil.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-09-13  |  63.1 KB  |  1,903 lines
  1. /* National Institute of Standards and Technology (NIST)
  2. /* National Computer System Laboratory (NCSL)
  3. /* Office Systems Engineering (OSE) Group
  4. /* ********************************************************************
  5. /*                            D I S C L A I M E R
  6. /*                              (March 8, 1989)
  7. /*  
  8. /* There is no warranty for the NIST NCSL OSE SGML parser and/or the NIST
  9. /* NCSL OSE SGML parser validation suite.  If the SGML parser and/or
  10. /* validation suite is modified by someone else and passed on, NIST wants
  11. /* the parser's recipients to know that what they have is not what NIST
  12. /* distributed, so that any problems introduced by others will not
  13. /* reflect on our reputation.
  14. /* 
  15. /* Policies
  16. /* 
  17. /* 1. Anyone may copy and distribute verbatim copies of the SGML source
  18. /* code as received in any medium.
  19. /* 
  20. /* 2. Anyone may modify your copy or copies of SGML parser source code or
  21. /* any portion of it, and copy and distribute such modifications provided
  22. /* that all modifications are clearly associated with the entity that
  23. /* performs the modifications.
  24. /* 
  25. /* NO WARRANTY
  26. /* ===========
  27. /* 
  28. /* NIST PROVIDES ABSOLUTELY NO WARRANTY.  THE SGML PARSER AND VALIDATION
  29. /* SUITE ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
  30. /* EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  31. /* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  32. /* THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS
  33. /* WITH YOU.  SHOULD THE SGML PARSER OR VALIDATION SUITE PROVE DEFECTIVE,
  34. /* YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
  35. /* 
  36. /* IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL NIST BE LIABLE FOR
  37. /* DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER SPECIAL,
  38. /* INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
  39. /* INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA
  40. /* BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A
  41. /* FAILURE OF THE PROGRAM TO OPERATE WITH PROGRAMS NOT DISTRIBUTED BY
  42. /* NIST) THE PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF
  43. /* SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
  44. */
  45.  
  46. /************************************************************************/
  47. /*   TITLE:          SGML PARSER                                        */
  48. /*   SYSTEM:         DOCUMENT PROCESSOR                                 */
  49. /*   SUBSYSTEM:                                                         */
  50. /*   SOURCE FILE:    DIUTIL.C                                           */
  51. /*   AUTHOR:         Steven Lindeman, Fred Maples                       */
  52. /*                                                                      */
  53. /*   DATE CREATED:                                                      */
  54. /*   LAST MODIFIED:                                                     */
  55. /*                                                                      */
  56. /*                  REVISIONS                                           */
  57. /*   WHEN      WHO            WHY                                       */
  58. /************************************************************************/
  59. #include <stdio.h>
  60. #include <ctype.h>
  61. #include "didefs.h"
  62. #include "diglobal.h"
  63.  
  64. /*----------------------------------------------*/
  65. /*      A D A L L O C                 */
  66. /* Allocates enough memory for one  attri-   */
  67. /* bute description linked list entry. */
  68. /*----------------------------------------------*/
  69. ATTRDESC *adalloc()
  70. {
  71.    /*   char *calloc();*/
  72.    ATTRDESC *retptr;
  73.    if ((retptr=(ATTRPTR) malloc(sizeof(ATTRDESC))) == NULL)
  74.       ourexit(2,"\nInsufficient memory in parse3.\n");
  75.    return(retptr);
  76. }
  77.  
  78. /*----------------------------------------------*/
  79. /*               O Q A L L O C                  */
  80. /*----------------------------------------------*/
  81. OUT_QUEUE *oqalloc()
  82. {
  83.    /*   char *calloc();*/
  84.    OUT_QUEUE *retptr;
  85.    if ((retptr=(OUT_QUEUE_PTR) malloc(sizeof(OUT_QUEUE))) == NULL)
  86.       ourexit(2,"\nInsufficient memory in parse3.\n");
  87.    return(retptr);
  88. }
  89.  
  90. /*------------------------------------------------------*/
  91. /*                 C H E C K _ C R                      */
  92. /* This routine dumps out the carriage returns  */
  93. /* that were previously saved.  At this point we   */
  94. /* know they are significant.       */
  95. /*------------------------------------------------------*/
  96. void check_cr(num_cr,cr_found,first_time,end_of_elt)
  97. unsigned *num_cr;
  98. BOOLEAN cr_found,*first_time,end_of_elt;
  99. { 
  100.    if (*first_time) {
  101.       (*put_ctr)('\n',ctrfp);
  102.       *first_time = FALSE;
  103.    }
  104.    if (cr_found) {
  105.       (*print_ctr)(ctrfp,"|");
  106.       while((*num_cr)-->0)
  107.          (*print_ctr)(ctrfp,"\n[]");
  108.       if (!end_of_elt)
  109.          (*put_ctr)('\n',ctrfp);
  110.    }
  111.    return;
  112. }
  113.  
  114. /*--------------------------------------------------------------*/
  115. /*                     C H E C K _ E N T I T Y                 */
  116. /* This routine is called when a general entity reference   */
  117. /* has occurred either in the data stream or from an  */
  118. /* attribute value literal.            */
  119. /*--------------------------------------------------------------*/
  120. void check_entity(cdata_attr,num_csdata,entptr,datatext_read,entname,actual_length,inside_attr,inchar)
  121. BOOLEAN cdata_attr;
  122. unsigned *num_csdata;
  123. ENTITYDESC *entptr;
  124. BOOLEAN *datatext_read;
  125. char entname[];
  126. int *actual_length;
  127. BOOLEAN inside_attr;
  128. int *inchar;
  129. {
  130.    char str_to_unget[LITLEN+6];
  131.  
  132.    entstack[entitylevel] = lookstack();
  133.    if (++entitylevel > ENTLVL)
  134.       ourexit(2,"\nError: Nesting level of entities > ENTLVL\n");
  135.    switch(entptr->entitytype) {
  136.    case KW_MS:
  137.       sprintf(str_to_unget,"<![%s]]>",entptr->entityvalue);
  138.       break;
  139.    case KW_STARTTAG:
  140.       sprintf(str_to_unget,"<%s>",entptr->entityvalue);
  141.       break;
  142.    case KW_ENDTAG:
  143.       sprintf(str_to_unget,"</%s>",entptr->entityvalue);
  144.       break;
  145.    case KW_MD:
  146.       sprintf(str_to_unget,"<!%s>",entptr->entityvalue);
  147.       break;
  148.    case KW_PI:
  149.       if (inside_attr)
  150.          ourexit(2,"\nError: Processing instruction invalid in attribute value literal.\n");
  151.       else {
  152.          (*print_ctr)(ctrfp,"\n[?%s]",entptr->entityvalue);
  153.          (*applic)(PROC_INST,entptr->entityvalue);
  154.       }
  155.       break;
  156.    case KW_CDATA: 
  157.    case KW_SDATA:
  158.       if (inside_attr && !cdata_attr)
  159.          ourexit(2,"\nError: CDATA or SDATA entity invalid in this attribute literal.\n");
  160.       strcpy(str_to_unget,entptr->entityvalue); 
  161.       *datatext_read = TRUE;
  162.       if (inside_attr)
  163.          *num_csdata += 1;  /* count of CDATA or SDATA references */
  164.       break;
  165.    case KW_SYSTEM: 
  166.    case KW_PUBLIC:
  167.       (*print_ctr)(ctrfp,"\n[&%s]",entname);
  168.       /*    if ((fpstack[++fpindx]=fopen("fred","rb")) == NULL)
  169.                ourexit(2,"Error: Unknown system entity reference.\n");
  170.       */
  171.       break;
  172.    default:
  173.       strcpy(str_to_unget,entptr->entityvalue); 
  174.       break;
  175.    }
  176.    if ((*inchar=our_fgetc(indoc)) != REFC)
  177.       if (*inchar == RE) { /* RS and RE are insignificant */
  178.          *inchar = our_fgetc(indoc);  /* get RS */
  179.          if (inside_attr)
  180.             *actual_length += 2;
  181.       }
  182.       else
  183.          our_ungetc(*inchar,indoc);
  184.    unget_entity(str_to_unget);
  185.    return;
  186. }
  187.  
  188. /*------------------------------------------------------*/
  189. /*               C H E C K _ F I X E D                  */
  190. /*     This routine guarantees that the attribute  */
  191. /*     declared as being FIXED matches the actual  */
  192. /*     value that was given.  If the two do not match */
  193. /*     exactly, an error condition is raised.      */
  194. /*------------------------------------------------------*/
  195. void check_fixed(defcode,str1,str2,length)
  196. ADFLT defcode;
  197. char str1[],str2[];
  198. int length;
  199. {
  200.    if (defcode==A_FIXED && strncmp(str1,str2,length)!=0) {
  201.       sprintf(error_msg,"%s'%s'.\n","\nError: FIXED attribute declared.  Must use ",str2);
  202.       FATAL_ERROR()
  203.    }
  204.    return;
  205. }
  206.  
  207. /*------------------------------------------------------*/
  208. /*       C R E A T E C M                      */
  209. /*                                                 */
  210. /*         Called by  :PUSHCREATE                     */
  211. /*                                                */
  212. /*         Returns    :pointer to the new             */
  213. /*                 content model                  */
  214. /*                                                */
  215. /*      Creates a copy of the given content model     */
  216. /*------------------------------------------------------*/
  217. TNODE *createcm(oldptr)
  218. TNODE *oldptr;
  219. {
  220.    TNODE *newptr,*newp,*oldp;
  221.  
  222.    if (oldptr != NULL) {
  223.       newptr = talloc();     /* allocate a node */
  224.       newptr->nodeid = oldptr->nodeid;    /* copy nodeid to new node */
  225.       newptr->occurind = newptr->copyoi = oldptr->occurind;
  226.       newptr->contreq = newptr->copycontreq = oldptr->contreq;
  227.       newptr->contref_attr = oldptr->contref_attr;
  228.  
  229.       /* ANDs are treated seperately, must build circular linked list
  230.                      instead of a binary tree.  each element in list is an element
  231.                      of the AND group */
  232.       if (oldptr->nodeid == AND) {
  233.          newp = newptr->u.llptr = createcm(oldptr->u.llptr);
  234.          oldp = oldptr->u.llptr;
  235.          while(oldp->next != oldptr->u.llptr) {
  236.             newp->next = createcm(oldp->next);  
  237.             oldp = oldp->next;
  238.             newp = newp->next;  /* move across both lists */
  239.          }
  240.          newp->next = newptr->u.llptr;   /* finish off circular list */
  241.       }
  242.       else {
  243.          newptr->left = createcm(oldptr->left);   /* create new left pointer */
  244.          newptr->u.right = createcm(oldptr->u.right); /* create new right ptr */
  245.       }
  246.       return(newptr);
  247.    }
  248.    return(NULL);
  249. }
  250.  
  251. /*------------------------------------------------------*/
  252. /*         C O M P A R E                  */
  253. /*                   */
  254. /*       Called by  :QSORT, BSEARCH                */
  255. /*                   */
  256. /*       Returns    :TRUE, FALSE                   */
  257. /*                   */
  258. /*       String compare to determine if two        */
  259. /*         strings are equal.                      */
  260. /*------------------------------------------------------*/
  261. compare(arg1,arg2)
  262. STENTRY *arg1,*arg2;
  263. {
  264.    return(strcmp((char *)arg1,(char *)arg2));
  265. }
  266.  
  267. /*------------------------------------------------------*/
  268. /*           D E C R O I                      */
  269. /*      This routine decrements the occurence indic-  */
  270. /* ators.  All that means is that an occurrence    */
  271. /* of this model token has occurred.      */
  272. /*------------------------------------------------------*/
  273. void decroi(ptr)
  274. TNODE *ptr;
  275. {
  276.    switch(ptr->occurind) {
  277.    case '+':          /* one or more   goes to  zero or more  */
  278.    case '*':          /* zero or more  goes to  zero or more  */
  279.       ptr->occurind = '*';
  280.       break;
  281. #ifdef NEW
  282.    case '*':          /* zero or more  goes to  zero or more  */
  283. #endif
  284.    case '?':          /* zero or one  goes to  none  */
  285.    case '1':          /* one          goes to  none  */
  286.       ptr->occurind = '#';
  287.       break;
  288.    default:
  289.       software_fault();
  290.    }
  291.    switch(ptr->contreq) {
  292.    case C_FTOTSO:
  293.       ptr->contreq = ptr->copycontreq = C_SOMETIMESO;
  294.       break;
  295.    case C_FTOWR:
  296.    case C_FTO:
  297.       ptr->contreq = C_NEVERO;
  298.       break;
  299.    case C_SOMETIMESO:
  300.    case C_NEVERO:
  301.    case C_ALWAYSO:
  302.       break;
  303.    default:
  304.       software_fault();
  305.    }
  306.    return;
  307. }
  308.  
  309. /*------------------------------------------------------*/
  310. /*               D E L E T E _ F I L E S                */
  311. /* Deletes temporary files built by DTD processor. */
  312. /* This routine is called only if the '-F' command */
  313. /* line option is left off.         */
  314. /*------------------------------------------------------*/
  315. void delete_files(path)
  316. char path[];
  317. {
  318.    char filename[PATHLEN];
  319.  
  320.    sprintf(filename,"%s%s",path,"dtdfile.sgm");
  321.    unlink(filename);
  322.    sprintf(filename,"%s%s",path,"attrfile.sgm");
  323.    unlink(filename);
  324.    sprintf(filename,"%s%s",path,"greffile.sgm");
  325.    unlink(filename);
  326.    sprintf(filename,"%s%s",path,"preffile.sgm");
  327.    unlink(filename);
  328.    sprintf(filename,"%s%s",path,"except.sgm");
  329.    unlink(filename);
  330.    return;
  331. }
  332.  
  333. /*----------------------------------------------*/
  334. /*         E X A L L O C                 */
  335. /* Allocates enough memory for one        */
  336. /* exception linked list entry.        */
  337. /*----------------------------------------------*/
  338. EXCEPTDESC *exalloc()
  339. {
  340.    /* char *calloc(); */
  341.    EXCEPTDESC *retptr;
  342.    if ((retptr=(EXCEPTPTR) malloc(sizeof(EXCEPTDESC))) == NULL)
  343.       ourexit(2,"\nInsufficient memory in parse3.\n");
  344.    return(retptr);
  345. }
  346.  
  347. /*------------------------------------------------------*/
  348. /*                 F L U S H _ B U F         */
  349. /*     This routine flushes the output buffer called  */
  350. /*     'outbuf' to the output document called 'outdoc'.  */
  351. /*     Outbuf is assumed to not be null terminated,   */
  352. /*     so a null is placed at the end of the buffer   */
  353. /*     pointed to by bufptr.           */
  354. /*------------------------------------------------------*/
  355. void flush_buf()
  356. {
  357.    if (bufptr != 0) {
  358.       outbuf[bufptr] = '\0';  /* bufptr always points to next entry place */
  359.       (*print_ctr)(ctrfp,"%s",outbuf);
  360.       bufptr = 0;  /* points to end of buffer, nothing in buffer now */
  361.    }
  362.    empty_queue();
  363.    return;
  364. }
  365.  
  366. /*----------------------------------------------*/
  367. /*      G E A L L O C                 */
  368. /* Allocates enough memory for one entity */
  369. /* description linked list entry.      */
  370. /*----------------------------------------------*/
  371. ENTITYDESC *gealloc()
  372. {
  373.    /* char *calloc(); */
  374.    ENTITYDESC *retptr;
  375.    if ((retptr=(ENTITYPTR) malloc(sizeof(ENTITYDESC))) == NULL)
  376.       ourexit(2,"\nInsufficient memory in parse3.\n");
  377.    return(retptr);
  378. }
  379.  
  380. /*----------------------------------------------*/
  381. /*      G R A L L O C                 */
  382. /* Allocates enough memory for one group  */
  383. /* description linked list entry.      */
  384. /*----------------------------------------------*/
  385. GROUPDESC *gralloc()
  386. {
  387.    /* char *calloc(); */
  388.    GROUPDESC *retptr;
  389.    if ((retptr=(GROUPPTR) malloc(sizeof(GROUPDESC))) == NULL)
  390.       ourexit(2,"\nInsufficient memory in parse3.\n");
  391.    return(retptr);
  392. }
  393.  
  394. /*----------------------------------------------*/
  395. /*    I D _ I D R E F _ A L L O C          */
  396. /* Allocates enough memory for one ID or  */
  397. /* IDREF description linked list entry.   */
  398. /*----------------------------------------------*/
  399. ID_IDREF_DESC *id_idref_alloc()
  400. {
  401.    /* char *calloc(); */
  402.    ID_IDREF_DESC *retptr;
  403.    if ((retptr=(ID_IDREF_PTR) malloc(sizeof(ID_IDREF_DESC))) == NULL)
  404.       ourexit(2,"\nInsufficient memory in parse3.\n");
  405.    return(retptr);
  406. }
  407.  
  408. /*------------------------------------------------------*/
  409. /*                     I N C R O I                      */
  410. /*        Increments the occurence indicators.     */
  411. /*------------------------------------------------------*/
  412. void incroi(ptr)
  413. TNODE *ptr;
  414. {
  415.    switch(ptr->occurind) {
  416.    case '*':
  417.       ptr->occurind = '+';  /* zero or more goes to one or more */
  418.       break;
  419.    case '?':
  420.       ptr->occurind = '1';  /* optional goes to required */
  421.       break;
  422.    default:
  423.       software_fault();
  424.    }
  425.    return;
  426. }
  427.  
  428. /*------------------------------------------------------*/
  429. /*                   I N P U T _ P S                    */
  430. /* This routine is used to input parameter      */
  431. /* seperators that can be found in the front */
  432. /* part of marked sections.  It gets as many */
  433. /* as possible and returns the number that it   */
  434. /* found.                  */
  435. /*------------------------------------------------------*/
  436. inputps(penthead)
  437. ENTITYDESC *penthead;
  438. {
  439.    int inchar;
  440.    unsigned sepcount = 0;
  441.  
  442.    for(;;) {
  443.       switch (inchar=our_fgetc(indoc)) {
  444.       case RS:
  445.       case RE:   
  446.       case SPACE:  
  447.          sepcount++;
  448.          break;
  449.       case OUR_EE:
  450.          sepcount++;
  451.          entitylevel--;
  452.          break;
  453.          /* must check if parameter entity reference */
  454.       case PERO:
  455.          if ((inchar = our_fgetc(indoc)) == EOF)
  456.             return(EOF);
  457.          /* if it is a parameter entity reference ...*/
  458.          if (isalpha(inchar)){
  459.             our_ungetc(inchar, indoc);
  460.             if (++entitylevel > ENTLVL)
  461.                ourexit(2,"\nError: Number of open entities > ENTLVL\n");
  462.             reslvpref(penthead);
  463.             sepcount++;
  464.             break;
  465.          }
  466.          else {
  467.             our_ungetc(inchar, indoc);
  468.             our_ungetc(PERO, indoc);
  469.             return(sepcount);
  470.          }
  471.       case '-':
  472.          if ((inchar = our_fgetc(indoc)) == EOF)
  473.             return(EOF);
  474.          if (inchar == '-') {
  475.             inpcomment();
  476.             sepcount++;
  477.             break;
  478.          }
  479.          our_ungetc(inchar, indoc);
  480.          our_ungetc('-', indoc);
  481.          return(sepcount);
  482.       default:
  483.          our_ungetc(inchar, indoc);
  484.          return(sepcount);
  485.       }
  486.    }
  487. }
  488.  
  489. /*------------------------------------------------------*/
  490. /*                I N P C O M M E N T                   */
  491. /* This routine inputs a comment from indoc. */
  492. /*------------------------------------------------------*/
  493. void inpcomment()
  494. { 
  495.    int inchar;
  496.    for(;;) {
  497.       if ((inchar=our_fgetc(indoc)) == EOF)
  498.          ourexit(2,"\nError: EOF found while processing comment");
  499.       if (inchar != '-') 
  500.          continue;
  501.       if ((inchar=our_fgetc(indoc)) == EOF)
  502.          ourexit(2,"\nError: EOF found while processing comment");
  503.       if (inchar == '-')
  504.          return;
  505.    }
  506.    return;
  507. }
  508.  
  509. /*------------------------------------------------------*/
  510. /*         I S A L L O C                  */
  511. /* This routine allocates enough memory for one */
  512. /* input stack entry.                        */
  513. /*------------------------------------------------------*/
  514. INPUT_STACK *isalloc()
  515. {
  516.    /* char *calloc(); */
  517.    INPUT_STACK *retptr;
  518.    if ((retptr=(INPUT_STACK_PTR) malloc(sizeof(INPUT_STACK))) == NULL)
  519.       ourexit(2,"\nInsufficient memory in parse3.\n");
  520.    return(retptr);
  521. }
  522.  
  523. /*------------------------------------------------------*/
  524. /*              L I N S R C H             */
  525. /*      This routine performs a search on the symbol    */
  526. /*      table for the address of the record correspond- */
  527. /*      ing to the token passed to it.  If there is   */
  528. /*      not an entry in the symbol table for that  */
  529. /*      token, a NULL ptr is returned.       */
  530. /*------------------------------------------------------*/
  531. STENTRY *linsrch(symtable,token,numsym)
  532. STENTRY symtable[];
  533. int token,numsym;
  534. {
  535.    int thissym;
  536.  
  537.    thissym = 0;
  538.    while(thissym!=numsym && symtable[thissym].tokenid!=token)
  539.       thissym++;
  540.    return(thissym < numsym ? &(symtable[thissym]) : NULL); 
  541. }
  542.  
  543. /*------------------------------------------------------*/
  544. /*                   O U R E X I T                      */
  545. /*                   */
  546. /*     Called by:     everybody           */
  547. /*                   */
  548. /*     Returns:       doesn't          */
  549. /*                   */
  550. /*     This routine prints an explanatory error    */
  551. /*     message and then terminates program execution.   */
  552. /*------------------------------------------------------*/
  553. void ourexit(errcode,msg)
  554. int errcode;
  555. char *msg;
  556. {
  557.    static int error_count=0;
  558.  
  559.    fprintf(stdout,"%s\n",msg);
  560.    switch(errcode) {
  561.    case 0:
  562.       break;
  563.    default:
  564.       exit(99);
  565.    }
  566.    if (error_count++ > MAX_ERRORS)
  567.       exit(99);
  568. }
  569.  
  570. /*------------------------------------------------------*/
  571. /*             P L A C E _ I N _ Q U E U E              */
  572. /*------------------------------------------------------*/
  573. void place_in_queue(thiscode,thisstr1,thisstr2)
  574. int thiscode;
  575. char *thisstr1,*thisstr2;
  576. {
  577.    OUT_QUEUE *ptr,*curr;
  578.  
  579.    ptr = oqalloc();
  580.    ptr->code = thiscode;
  581.    strcpy(ptr->str1,thisstr1);
  582.    strcpy(ptr->str2,thisstr2);
  583.    ptr->next = NULL;
  584.    if (head == NULL)
  585.       head = ptr;
  586.    else {
  587.       for (curr=head; curr->next!=NULL; curr=curr->next);
  588.       curr->next = ptr;
  589.    }
  590.    return;
  591. }
  592.  
  593. /*------------------------------------------------------*/
  594. /*                 E M P T Y _ Q U E U E                */
  595. /*------------------------------------------------------*/
  596. void empty_queue()
  597. {
  598.    OUT_QUEUE *curr,*temp;
  599.    for (curr=head; curr!=NULL; temp=curr, curr=curr->next, free((char *)temp)) {
  600.       switch(curr->code) {
  601.       case TAG_NAME:
  602.          (*applic)(TAG_NAME,curr->str1,"");
  603.          break;
  604.       case TAG_ATTR:
  605.          (*applic)(TAG_ATTR,curr->str1,curr->str2);
  606.          break;
  607.       case TAG_END:
  608.          (*applic)(TAG_END,"","");
  609.          break;
  610.       case DATA_STG:
  611.          (*applic)(DATA_STG,curr->str1,"");
  612.          break;
  613.       case PROC_INST:
  614.          (*applic)(PROC_INST,curr->str1,"");
  615.          break;
  616.       case END_TAG_NAME:
  617.          (*applic)(END_TAG_NAME,curr->str1,"");
  618.          break;
  619.       }
  620.    }
  621.    head = NULL;
  622.    return;
  623. }
  624.  
  625. /*------------------------------------------------------*/
  626. /*                C L E A R _ Q U E U E                 */
  627. /*------------------------------------------------------*/
  628. void clear_queue()
  629. {
  630.    OUT_QUEUE *curr,*temp;
  631.    for (curr=head; curr!=NULL; temp=curr, curr=curr->next, free((char *)temp));
  632.    head = NULL;
  633.    return;
  634. }
  635.  
  636. /*------------------------------------------------------*/
  637. /*       P U S H                          */
  638. /*                                                 */
  639. /*         Called by  :PUSHCREATE, LOOKSTACK       */
  640. /*                                                 */
  641. /*         Returns    :VOID                        */
  642. /*                                                 */
  643. /*         Pushes a symbol table entry             */
  644. /*           pointer onto a push-down stack.       */
  645. /*------------------------------------------------------*/
  646. void push(ptr)
  647. STENTRY *ptr;
  648. {
  649.    if (sp < TAGLVL)
  650.       stack[sp++]=ptr;    /* push ptr on stack */
  651.    else             /* stack exceeds TAGLVL (24) */
  652.       ourexit(2,"\nError: Number of open elements > TAGLVL.\n");
  653.    return;
  654. }
  655.  
  656. /*------------------------------------------------------*/
  657. /*       P O P             */
  658. /*          Called by  :POPFREE, LOOKSTACK              */
  659. /*          Returns    :pointer to symbol table entry   */
  660. /*                                                */
  661. /*          Pops a symbol table entry pointer         */
  662. /*        off of a push-down stack               */
  663. /*------------------------------------------------------*/
  664. STENTRY *pop()
  665. {
  666.    if (sp > 0)
  667.       return(stack[--sp]);    /* pop ptr off stack */
  668.    else
  669.       return(NULL);
  670. }
  671.  
  672. /*------------------------------------------------------*/
  673. /*         P O P F R E E                     */
  674. /*      This routine pops a ptr from content model ptr  */
  675. /* stack and deletes corresponding content model.  */
  676. /*------------------------------------------------------*/
  677. STENTRY *popfree(ptr)
  678. TNODE *ptr;
  679. {
  680.    STENTRY *retptr;
  681.    EXCEPTDESC *p;
  682.  
  683.    retptr = pop();
  684.    retptr->num_open--;
  685.  
  686.    if (currexcl!=NULL && retptr->miniexcept&EXCL_MASK && retptr->num_open==0) {
  687.       if (currexcl == retptr->exclusion)
  688.          currexcl = NULL;
  689.       else {
  690.          p = last_sublist(currexcl,retptr->exclusion);  /* P can't be NULL */
  691.          p->nextglobal = NULL;
  692.       }
  693.       retptr->miniexcept &= ~EXCL_MASK;  /* disallow exclusions */
  694.    }
  695.  
  696.    if (currincl!=NULL && retptr->miniexcept&INCL_MASK && retptr->num_open==0) {
  697.       if (currincl == retptr->inclusion)
  698.          currincl = NULL;
  699.       else {
  700.          p = last_sublist(currincl,retptr->inclusion); /* P can't be NULL */
  701.          p->nextglobal = NULL;
  702.       }
  703.       retptr->miniexcept &= ~INCL_MASK;  /* disallow inclusions */
  704.    }
  705.    delete(ptr);
  706.    return(retptr);
  707. }
  708.  
  709. /*------------------------------------------------------*/
  710. /*                 P U S H C R E A T E                */
  711. /*                   */
  712. /*      Returns:    ptr to new content model    */
  713. /*                   */
  714. /*      pushes ptr on stack and creates a          */
  715. /*      content model from the virgin copy         */
  716. /*------------------------------------------------------*/
  717. TNODE *pushcreate(tp)
  718. STENTRY *tp;
  719. {
  720.    EXCEPTDESC *p;
  721.  
  722.    tp->num_open++;   /* number of currently open elements for this one */
  723.  
  724.    if (!(tp->miniexcept & EXCL_MASK))
  725.       if ((p=last_global(currexcl)) == NULL)
  726.          currexcl = tp->exclusion;
  727.       else
  728.          p->nextglobal = tp->exclusion;
  729.    if (tp->exclusion != NULL)
  730.       tp->miniexcept |= EXCL_MASK;
  731.  
  732.    if (!(tp->miniexcept & INCL_MASK))
  733.       if ((p=last_global(currincl)) == NULL)
  734.          currincl = tp->inclusion;
  735.       else
  736.          p->nextglobal = tp->inclusion;
  737.    if (tp->inclusion != NULL)
  738.       tp->miniexcept |= INCL_MASK;
  739.  
  740.    if (find_except(currexcl,tp->tokenid) == TRUE) {
  741.       sprintf(error_msg,"\n%s%s%s\n","Error: Invalid tokenid, ",tp->nametoken," is excluded.");
  742.       FATAL_ERROR()
  743.    }
  744.    push(tp);
  745.    return(createcm(tp->cmptr));
  746. }
  747.  
  748. /*------------------------------------------------------*/
  749. /*            P U T C H A R _ O U T B U F               */
  750. /*        Puts a character into the output buffer.      */
  751. /*------------------------------------------------------*/
  752. void putchar_outbuf(inchar)
  753. int inchar;
  754. {
  755.    outbuf[bufptr++] = inchar;
  756.    if (bufptr >= TAGLEN+200)
  757.       flush_buf();
  758.    return;
  759. }
  760.  
  761. /*------------------------------------------------------*/
  762. /*              P U T S T R _ O U T B U F               */
  763. /*     Puts a character string into the output buffer   */
  764. /*------------------------------------------------------*/
  765. void putstr_outbuf(string)
  766. char string[];
  767. {
  768.    if (bufptr+strlen(string) >= TAGLEN+200)
  769.       flush_buf();
  770.    if (strlen(string) >= TAGLEN+200)
  771.       (*print_ctr)(ctrfp,"%s",string);
  772.    outbuf[bufptr] = '\0';
  773.    strcat(outbuf,string);
  774.    bufptr += strlen(string); /* don't need the null string yet */
  775.    return;
  776. }
  777.  
  778. /*------------------------------------------------------*/
  779. /*                   R E D U C E O I                    */
  780. /*      This routine reduces the occurence indicators.  */
  781. /* This is done in the initilization part to make  */
  782. /* sub-models optional if their parent nodes are   */
  783. /* optional.               */
  784. /*------------------------------------------------------*/
  785. void reduceoi(ptr)
  786. TNODE *ptr;
  787. {
  788.    switch(ptr->occurind) {
  789.    case '+':
  790.       ptr->copyoi = ptr->occurind = '*';
  791.       break;
  792.    case '1':
  793.       ptr->copyoi = ptr->occurind = '?';
  794.       break;
  795.    default:
  796.       software_fault();
  797.    }
  798.    return;
  799. }
  800.  
  801. /*------------------------------------------------------*/
  802. /*                 R E S T O R E O I                    */
  803. /*     This routine restores the occurance indicators   */
  804. /*     of the whole tree to their original values       */
  805. /*------------------------------------------------------*/
  806. void restoreoi(ptr)
  807. TNODE *ptr;
  808. {
  809.    TNODE *currp;
  810.  
  811.    if (ptr != NULL) {
  812.       if (ptr->nodeid == AND) {
  813.          currp = ptr->u.llptr;
  814.          while(currp->next != ptr->u.llptr) {  /* restore each one in list */
  815.             restoreoi(currp);
  816.             currp = currp->next;
  817.          }
  818.          restoreoi(currp);  /* don't forget to restore last one  */
  819.       }
  820.       else {
  821.          restoreoi(ptr->left);    /* restore left subtree */
  822.          restoreoi(ptr->u.right); /* restore right subtree */
  823.       }
  824.       ptr->occurind = ptr->copyoi;  /* restores oi from unused copy */
  825.       switch(ptr->contreq) {
  826.       case C_NEVERO:
  827.          if (ptr->copycontreq != C_FTO)
  828.             ptr->contreq = ptr->copycontreq;
  829.          break;
  830.       case C_SOMETIMESO:
  831.          if (ptr->copycontreq != C_FTOTSO)
  832.             ptr->contreq = ptr->copycontreq;
  833.          break;
  834.       default:
  835.          ptr->contreq = ptr->copycontreq;
  836.          break;
  837.       }
  838.    }
  839.    return;
  840. }
  841.  
  842. /*------------------------------------------------------*/
  843. /*    R E Q _ N O T _ P R O C       */
  844. /* Traverses through the attribute list to decide  */
  845. /* if any attributes were REQUIRED but not pro- *
  846. /* cessed.  FALSE is returned if none were found   */
  847. /* and TRUE is returned if at least one was found. */
  848. /*------------------------------------------------------*/
  849. req_not_proc(thisadp)
  850. ATTRDESC *thisadp;
  851. {
  852.    BOOLEAN retval;
  853.    retval = FALSE;
  854.    while(retval==FALSE && thisadp!=NULL)
  855.       if ((thisadp->processed==FALSE) && ((thisadp->defcode==A_REQD) ||
  856.           (thisadp->defcode==A_CURRENT && thisadp->u2.currgrp==NULL)))
  857.          retval = TRUE;
  858.       else
  859.          thisadp = thisadp->next;
  860.    return(retval);
  861. }
  862.  
  863. /*------------------------------------------------------*/
  864. /*        R E S L V P R E F         */
  865. /* This routine resolves any parameter entity refer-    */
  866. /* ences at a separator level. It inputs the entity     */
  867. /* name, searches a table on the name getting its  */
  868. /* entity text, and 'ungets' the text for further  */
  869. /* processing.                                        */
  870. /*------------------------------------------------------*/
  871. void reslvpref(penthead)
  872. ENTITYDESC *penthead;
  873. {
  874.    char namearray[NAMELEN+1];
  875.    char tarray[LITLEN+6];
  876.    int inchar;
  877.    ENTITYDESC *entptr;
  878.  
  879.    /* input the parameter entity name */
  880.    if (get_entname(namearray,nullfnc) < NAMELEN-1) {
  881.  
  882.       if ((entptr=find_entity(penthead,namearray,FALSE)) == NULL) {
  883.          sprintf(error_msg,"\n%s'%s'.\n","Error: Unknown parameter entity reference ",namearray);
  884.          FATAL_ERROR()
  885.       }
  886.       switch(entptr->entitytype){
  887.       case KW_MD:
  888.          sprintf(tarray,"%s%s%s","<!",entptr->entityvalue,">");
  889.          if ((inchar=our_fgetc(indoc)) != EOF)
  890.             ourexit(2,"\nError: EOF found while resolving parameter entity reference.\n");
  891.          if (inchar != REFC)
  892.             if (inchar == RE)   /* RS and RE are insignificant */
  893.                inchar = our_fgetc(indoc);  /* get RS */
  894.             else
  895.                our_ungetc(inchar, indoc);
  896.          unget_entity(tarray);
  897.          break;
  898.       case KW_ENDTAG:
  899.          sprintf(tarray,"%s%s%s","</",entptr->entityvalue,">");
  900.          if ((inchar=our_fgetc(indoc)) != EOF)
  901.             ourexit(2,"\nError: EOF found while resolving parameter entity reference.\n");
  902.          if (inchar != REFC)
  903.             if (inchar == RE)   /* RS and RE are insignificant */
  904.                inchar = our_fgetc(indoc);  /* get RS */
  905.             else
  906.                our_ungetc(inchar, indoc);
  907.          unget_entity(tarray);
  908.          break;
  909.       case KW_STARTTAG:
  910.          sprintf(tarray,"%s%s%s","<",entptr->entityvalue,">");
  911.          if ((inchar=our_fgetc(indoc)) != EOF)
  912.             ourexit(2,"\nError: EOF found while resolving parameter entity reference.\n");
  913.          if (inchar != REFC)
  914.             if (inchar == RE)   /* RS and RE are insignificant */
  915.                inchar = our_fgetc(indoc);  /* get RS */
  916.             else
  917.                our_ungetc(inchar, indoc);
  918.          unget_entity(tarray);
  919.          break;
  920.       case KW_MS:
  921.          sprintf(tarray,"%s%s%s","<![",entptr->entityvalue,"]]>");
  922.          if ((inchar=our_fgetc(indoc)) == EOF)
  923.             ourexit(2,"\nError: EOF found while resolving parameter entity reference.\n");
  924.          if (inchar != REFC)
  925.             if (inchar == RE)   /* RS and RE are insignificant */
  926.                inchar = our_fgetc(indoc);  /* get RS */
  927.             else
  928.                our_ungetc(inchar, indoc);
  929.          unget_entity(tarray);
  930.          break;
  931.       case NULL:
  932.          if ((inchar=our_fgetc(indoc)) == EOF)
  933.             ourexit(2,"\nError: EOF found while resolving parameter entity reference");
  934.          if (inchar != REFC)
  935.             if (inchar == RE)   /* RS and RE are insignificant */
  936.                inchar = our_fgetc(indoc);  /* get RS */
  937.             else
  938.                our_ungetc(inchar, indoc);
  939.          /* unget parameter literal */
  940.          unget_entity(entptr->entityvalue);
  941.          break;
  942.          /* any other syntactic literal is illegal */
  943.       default:
  944.          ourexit(2,"\nError: Illegal use of syntactic literal in a PS entity reference.\n");
  945.          break;
  946.       }
  947.    }
  948.    else
  949.       ourexit(2,"\nError: Reference name not found in PS entity reference.\n");
  950.    return;
  951. }
  952.  
  953. /*------------------------------------------------------*/
  954. /*                  S A V E _ C R S                     */
  955. /* During the processing of data, carriage returns */
  956. /* are read and saved.  They may be output later   */
  957. /* if it is found that are significant.      */
  958. /*------------------------------------------------------*/
  959. BOOLEAN save_crs(num_cr,inchar)
  960. unsigned *num_cr;
  961. int *inchar;
  962. {
  963.    BOOLEAN cr_found;
  964.    for (cr_found = FALSE; *inchar == RE; (*num_cr)++) {
  965.       cr_found = TRUE;
  966.       if ((*inchar=our_fgetc(indoc)) == RS)  /* should be a RS */
  967.          *inchar = our_fgetc(indoc);
  968.    }
  969.    return(cr_found);
  970. }
  971.  
  972. /*------------------------------------------------------*/
  973. /*    S O F T W A R E _ F A U L T      */
  974. /* This routine should NEVER be called.  If it  */
  975. /* is called, the parser has taken an unpredicted  */
  976. /* path of execution and the program is halted. */
  977. /*------------------------------------------------------*/
  978. void software_fault()
  979. {
  980.    fprintf(stderr,"Internal parser error.  Contact Jim Heath of NBS @ (301) 975-3350.\n");
  981.    exit(99);
  982. }
  983.  
  984. /*----------------------------------------------*/
  985. /*      T A L L O C                   */
  986. /*                                              */
  987. /*     Called by   :BUILDTREE                   */
  988. /*                                              */
  989. /*     Returns     :ptr to allocated node       */
  990. /*                                              */
  991. /*     Allocates memory for one tree node.      */
  992. /*----------------------------------------------*/
  993. TNODE *talloc()
  994. {
  995.    /* char *calloc(); */
  996.    TNODE *retptr;
  997.    if ((retptr=(TPTR) malloc(sizeof(TNODE))) == NULL)
  998.       ourexit(2,"\nInsufficient memory in parse3.\n");
  999.    return(retptr);
  1000. }
  1001.  
  1002. /*------------------------------------------------------*/
  1003. /*                    T E S T O I                       */
  1004. /*     This routine tests to see if occurance indicator */
  1005. /*     is mandatory or optional.                   */
  1006. /*------------------------------------------------------*/
  1007. OCCURIND testoi(ptr)
  1008. TNODE *ptr;
  1009. {
  1010.    OCCURIND retval;
  1011.  
  1012.    switch(ptr->occurind) {
  1013.    case '1':         /* occurind is one */
  1014.       retval = ONE;
  1015.       break;
  1016.    case '+':         /* occurind is one or more */
  1017.       retval = PLUS;
  1018.       break;
  1019.    case '?':         /* occurind is zero or one */
  1020.    case '*':         /* occurind is zero or more */
  1021.       retval = OPT;
  1022.       break;
  1023.    case '#':         /* occurind is none */
  1024.       retval = OI_IS_NULL;
  1025.       break;
  1026.    default:
  1027.       software_fault();
  1028.    }
  1029.    return(retval);
  1030. }
  1031.  
  1032. /*------------------------------------------------------*/
  1033. /*                U N G E T _ E N T I T Y               */
  1034. /* This routine simply 'ungets' the given entity   */
  1035. /* string onto the input stack.  First the SGML */
  1036. /* 'Ee' (Entity end) signal is pushed on the */
  1037. /* stack, then the string is pushed in reverse  */
  1038. /* order by unget_string.           */
  1039. /*------------------------------------------------------*/
  1040. void unget_entity(string)
  1041. char string[];
  1042. {
  1043.    our_ungetc(OUR_EE,indoc);
  1044.    unget_string(string);
  1045.    return;
  1046. }
  1047.  
  1048. /*------------------------------------------------------*/
  1049. /*                U N G E T _ S T R I N G               */
  1050. /* This routine simply 'ungets' the given string   */
  1051. /* onto the input stack.   Remember that the    */
  1052. /*      string must be processed in reverse order. */
  1053. /*------------------------------------------------------*/
  1054. void unget_string(string)
  1055. char string[];
  1056. {
  1057.    register int i;
  1058.    for (i=strlen(string)-1; i>=0; i--)
  1059.       our_ungetc(string[i],indoc);
  1060.    return;
  1061. }
  1062.  
  1063. /*------------------------------------------------------*/
  1064. /*          U N G E T T O K E N                  */
  1065. /*  Places the given token (tag) back onto the     */
  1066. /*       input stream.                        */
  1067. /*------------------------------------------------------*/
  1068. void ungettoken(token,tp)
  1069. int token;
  1070. STENTRY *tp;
  1071. {
  1072.    state = GETOLD;     /* set state to read from input stream */
  1073.    holdtoken = token;
  1074.    holdtp = tp;        /* get table location from hold area */
  1075.    return;
  1076. }
  1077.  
  1078. /*------------------------------------------------------*/
  1079. /*         U N P R O C E S S        */
  1080. /* Traverses through the attribute list and  */
  1081. /* turns off the flag describing whether this   */
  1082. /* name has been processed in this tag.      */
  1083. /*------------------------------------------------------*/
  1084. void unprocess(thisadp)
  1085. ATTRDESC *thisadp;
  1086. {
  1087.    while(thisadp != NULL) {
  1088.       thisadp->processed = FALSE;
  1089.       thisadp = thisadp->next;
  1090.    }
  1091.    return;
  1092. }
  1093.  
  1094. /*--------------------------------------------------------------*/
  1095. /*                 C H E C K _ F O R _ M D O                   */
  1096. /* This routine is called when the "<!" has already   */
  1097. /* been read while processing PCDATA.        */
  1098. /*--------------------------------------------------------------*/
  1099. STATUS check_for_mdo(more_subdata,num_cr,cr_found,pcdata_ft)
  1100. BOOLEAN *more_subdata;
  1101. unsigned *num_cr;
  1102. BOOLEAN cr_found,*pcdata_ft;
  1103. {
  1104.    int inchar;
  1105.    STATUS retval;
  1106.  
  1107.    if ((inchar=our_fgetc(indoc)) == '-')
  1108.       if ((inchar=our_fgetc(indoc)) == '-') {
  1109.          unget_string("<!--");
  1110.          *more_subdata = FALSE;
  1111.       }
  1112.       else {
  1113.          retval = FOUND;
  1114.          check_cr(num_cr,cr_found,pcdata_ft,FALSE);
  1115.          (*print_ctr)(ctrfp,"<!-");
  1116.          (*applic)(DATA_STG,"<!-","");
  1117.          our_ungetc(inchar,indoc);
  1118.       }
  1119.    else
  1120.       if (isalpha(inchar) || inchar=='[' || inchar==MARKUP_END) {
  1121.          our_ungetc(inchar,indoc);
  1122.          unget_string("<!");   
  1123.          *more_subdata = FALSE;
  1124.       }
  1125.       else {
  1126.          retval = FOUND;
  1127.          check_cr(num_cr,cr_found,pcdata_ft,FALSE);
  1128.          (*print_ctr)(ctrfp,"<!");
  1129.          (*applic)(DATA_STG,"<!","");
  1130.          our_ungetc(inchar,indoc);
  1131.       }
  1132.    return(retval);
  1133. }
  1134.  
  1135. /*------------------------------------------------------*/
  1136. /*    C R O S S _ I D _ I D R E F      */
  1137. /* Performs a cross reference evaluation for IDs   */
  1138. /* and IDREFs to make sure there is an ID found */
  1139. /* for every IDREF.  There is no requirement that  */
  1140. /* states an IDREF must be found for every ID.  */
  1141. /*------------------------------------------------------*/
  1142. ID_IDREF_DESC *cross_id_idref(idptr,idrefptr)
  1143. ID_IDREF_DESC *idptr,*idrefptr;
  1144. {
  1145.    while(idrefptr!=NULL && find_id(idptr,idrefptr->name)==TRUE)
  1146.       idrefptr = idrefptr->next;
  1147.    return(idrefptr);
  1148. }
  1149.  
  1150. /*------------------------------------------------------*/
  1151. /*       D E L E T E                     */
  1152. /*                                               */
  1153. /*     Called by  :DELETE,POPFREE                  */
  1154. /*                                                 */
  1155. /*     Returns    :VOID                            */
  1156. /*                                               */
  1157. /*     Deletes the binary tree pointed to by ptr   */
  1158. /*------------------------------------------------------*/
  1159. void delete(ptr)
  1160. TNODE *ptr;
  1161. {
  1162.    TNODE *currp,*futp;
  1163.    if (ptr != NULL) {
  1164.       if (ptr->nodeid == AND) {
  1165.          currp = ptr->u.llptr;
  1166.          while(currp->next != ptr->u.llptr) {
  1167.             futp = currp->next;
  1168.             /* must save a ptr to node to be processed next, futp, 
  1169.                                               because will 'delete' ptr to it now */
  1170.             delete(currp);
  1171.             currp = futp;
  1172.          }
  1173.          delete(currp);  /* don't forget last one in list */
  1174.       }
  1175.       else {
  1176.          delete(ptr->left);    /* delete left subtree */
  1177.          delete(ptr->u.right);   /* delete right subtree */
  1178.          free((char *)ptr);            /* unallocate memory location */
  1179.       }
  1180.    }
  1181.    return;
  1182. }
  1183.  
  1184. /*------------------------------------------------------*/
  1185. /*         F I N D _ A T T R        */
  1186. /* Searches through the attribute list for the  */
  1187. /* given name and returns the pointer to list   */
  1188. /* entry if found, else returns NULL.     */
  1189. /*------------------------------------------------------*/
  1190. ATTRDESC *find_attr(thisattr,thisadp)
  1191. char thisattr[];
  1192. ATTRDESC *thisadp;
  1193. {
  1194.    while((thisadp!=NULL) && (strcmp(thisattr,thisadp->attrname)!=0))
  1195.       thisadp = thisadp->next;
  1196.    return(thisadp);
  1197. }
  1198.  
  1199. /*------------------------------------------------------*/
  1200. /*       F I N D _ G R O U P        */
  1201. /* Searches through the group list for the   */
  1202. /* given name and returns the pointer to list   */
  1203. /* entry if found, else returns NULL.     */
  1204. /*------------------------------------------------------*/
  1205. GROUPDESC *find_group(thisgroup,thisgrp)
  1206. char thisgroup[];
  1207. GROUPDESC *thisgrp;
  1208. {
  1209.    while((thisgrp!=NULL) && (strcmp(thisgroup,thisgrp->groupname)!=0))
  1210.       thisgrp = thisgrp->next;
  1211.    return(thisgrp);
  1212. }
  1213.  
  1214. /*------------------------------------------------------*/
  1215. /*          F I N D _ I D        */
  1216. /* Searches through the ID list for the given   */
  1217. /* name and returns the pointer to the list  */
  1218. /* entry if the name is found, else returns NULL.  */
  1219. /*------------------------------------------------------*/
  1220. BOOLEAN find_id(idptr,thisname)
  1221. ID_IDREF_DESC *idptr;
  1222. char thisname[];
  1223. {
  1224.    while(idptr!=NULL && strcmp(idptr->name,thisname)!=0)
  1225.       idptr = idptr->next;
  1226.    return(idptr!=NULL ? TRUE : FALSE);
  1227. }
  1228.  
  1229. /*------------------------------------------------------*/
  1230. /*           F I N D _ E N T I T Y        */
  1231. /* Searches through the ENTITY list for the given  */
  1232. /* name and returns the pointer to the list  */
  1233. /* entry if the name is found, else returns NULL.  */
  1234. /* If there is a #DEFAULT entry and a direct       */
  1235. /* match is not found, the ptr to the first        */
  1236. /* #DEFAULT entry is returned.                     */
  1237. /*------------------------------------------------------*/
  1238. ENTITYDESC *find_entity(entptr,thisname,look_for_default)
  1239. ENTITYDESC *entptr;
  1240. char thisname[];
  1241. BOOLEAN look_for_default;
  1242. {
  1243.    ENTITYDESC *first_def;
  1244.  
  1245.    first_def = NULL;  /* points to first #DEFAULT entry in list */
  1246.    while(entptr!=NULL && strcmp(entptr->entityname,thisname)!=0) {
  1247.       if (first_def==NULL && look_for_default && strcmp(entptr->entityname,"#DEFAULT")==0)
  1248.          first_def = entptr;
  1249.       entptr = entptr->next;
  1250.    }
  1251.    return(entptr==NULL ? first_def : entptr);
  1252. }
  1253.  
  1254. /*------------------------------------------------------*/
  1255. /*                F I N D _ E X C E P T                 */
  1256. /* This routine searches the exception list  */
  1257. /* (inclusion or exclusion) for the identifier  */
  1258. /* specified in the parameter list.    */
  1259. /*------------------------------------------------------*/
  1260. BOOLEAN find_except(exptr,thisid)
  1261. EXCEPTDESC *exptr;
  1262. int thisid;
  1263. {
  1264.    while(exptr!=NULL && exptr->tokenid!=thisid)
  1265.       exptr = exptr->nextglobal;
  1266.    return(exptr!=NULL ? TRUE : FALSE);
  1267. }
  1268.  
  1269. /*------------------------------------------------------*/
  1270. /*          I N S E R T       */
  1271. /* This routine inserts IDs or IDREFs at the end   */
  1272. /* of their appropriate seperate singly linked  */
  1273. /* lists.  A flag is passed to indicate which   */
  1274. /* list the name is to be added to.  If the name   */
  1275. /* is already present in the list, an error is  */
  1276. /* raised.                 */
  1277. /*------------------------------------------------------*/
  1278. void insert(head,thisname,declvalcode)
  1279. ID_IDREF_DESC **head;
  1280. char thisname[];
  1281. DECLVAL declvalcode;
  1282. {
  1283.    ID_IDREF_DESC *thisptr,*prevptr;
  1284.  
  1285.    thisptr = *head;
  1286.    while(thisptr!=NULL && strcmp(thisptr->name,thisname)!=0) {
  1287.       prevptr = thisptr;
  1288.       thisptr = thisptr->next;
  1289.    }
  1290.    if (thisptr==NULL && strcmp(prevptr->name,thisname)!=0) {
  1291.       if (*head == NULL)
  1292.          thisptr = *head = id_idref_alloc();
  1293.       else 
  1294.           thisptr = prevptr->next = id_idref_alloc();
  1295.       strcpy(thisptr->name,thisname);
  1296.       thisptr->next = NULL;
  1297.    }
  1298.    else
  1299.       if (declvalcode == ID) {
  1300.          sprintf(error_msg,"%s%s%s","\nError: Duplicate ID attribute values of '",thisname,"'.\n");
  1301.          FATAL_ERROR()
  1302.       }
  1303.    return;
  1304. }
  1305.  
  1306. /*------------------------------------------------------*/
  1307. /*               L A S T _ S U B L I S T                */
  1308. /* This routine is used to find the end of the  */
  1309. /*      sub-exception list.  That is, the list of  */
  1310. /*      elements declared as an exception for that */
  1311. /*      particular generic identifier.       */
  1312. /*------------------------------------------------------*/
  1313. EXCEPTDESC *last_sublist(thisglob,thisloc)
  1314. EXCEPTDESC *thisglob,*thisloc;
  1315. {
  1316.    if (thisglob==NULL || thisloc==NULL)
  1317.       software_fault();
  1318.  
  1319.    while(thisglob->nextglobal!=thisloc && thisglob->nextglobal!=NULL)
  1320.       thisglob = thisglob->nextglobal;
  1321.    return(thisglob);
  1322. }
  1323.  
  1324. /*------------------------------------------------------*/
  1325. /*               L A S T _ G L O B A L                  */
  1326. /* This routine is used to find the end of the  */
  1327. /*      entire exception list.  That is, the current  */
  1328. /*      list of elements active as an exception.   */
  1329. /*------------------------------------------------------*/
  1330. EXCEPTDESC *last_global(ptr)
  1331. EXCEPTDESC *ptr;
  1332. {
  1333.    if (ptr != NULL)
  1334.       while(ptr->nextglobal != NULL)
  1335.          ptr = ptr->nextglobal;
  1336.    return(ptr);
  1337. }
  1338.  
  1339. /*------------------------------------------------------*/
  1340. /*                L O O K S T A C K            */
  1341. /*                   */
  1342. /*        Returns    :top value on the stack            */
  1343. /*                                               */
  1344. /*        Returns the top value of the stack          */
  1345. /*        but does not pop it off.                    */
  1346. /*------------------------------------------------------*/
  1347. STENTRY *lookstack()
  1348. {
  1349.    STENTRY *ptr;
  1350.    if ((ptr=pop()) != NULL)    /*  pop value  */
  1351.       push(ptr);      /*  push it back on the stack  */
  1352.    return(ptr);
  1353. }
  1354.  
  1355. /*------------------------------------------------------*/
  1356. /*                    N U L L F N C                     */
  1357. /* This routine doesn't do much of anything. */
  1358. /* It is called by function prototypes to get   */
  1359. /* around calling certain routines.  For example,  */
  1360. /* we don't want to call 'our_fputc' when the   */
  1361. /* outdoc is not to be built.       */
  1362. /*------------------------------------------------------*/
  1363. nullfnc(value)
  1364. int value;
  1365. {
  1366.    return(value);
  1367. }
  1368.  
  1369. /*------------------------------------------------------*/
  1370. /*                  O U R _ F G E T C                   */
  1371. /*      This routine is similiar to K&R's standard */
  1372. /*      fgetc.  However, It does first read from our  */
  1373. /*      input stack if something exists on it.     */
  1374. /*      Otherwise, it does it's own fgetc.      */
  1375. /*------------------------------------------------------*/
  1376. our_fgetc(ind)
  1377. FILE *ind;
  1378. {
  1379.    register int inchar,retval;
  1380.    INPUT_STACK *delptr;
  1381.  
  1382.    /*  We are allowing for future revisions that might require the input
  1383.        for the document element parser to come from more than one source.  */
  1384.  
  1385.    if (stptr == NULL) {
  1386.       while ((retval=((inchar=fgetc(indoc))==CTRLZ ? EOF:inchar)) == EOF && --fpindx>=0) {
  1387.          fclose(fpstack[fpindx+1]);
  1388.          indoc = fpstack[fpindx];
  1389.          entitylevel--;
  1390.       }
  1391.       putchar(retval);
  1392.    }
  1393.    else {
  1394.       retval = stptr->inchar;
  1395.       delptr = stptr;
  1396.       stptr = stptr->next;
  1397.       free((char *)delptr);
  1398.    }
  1399.    return(retval);
  1400. }
  1401.  
  1402. /*------------------------------------------------------*/
  1403. /*                O U R _ U N G E T C                   */
  1404. /*      This routine is similiar to K&R's standard */
  1405. /*      ungetc.  However, It creates and uses its     */
  1406. /*      input stack and places the ungot character    */
  1407. /*      on it.                                  */
  1408. /*------------------------------------------------------*/
  1409. void our_ungetc(c,indoc)
  1410. int c;
  1411. FILE *indoc;
  1412. {
  1413.    INPUT_STACK *newptr;
  1414.  
  1415.    newptr = isalloc();
  1416.    newptr->inchar = c;
  1417.    newptr->next = stptr;
  1418.    stptr = newptr;
  1419.    return;
  1420. }
  1421.  
  1422. /*------------------------------------------------------*/
  1423. /*              O U R _ T O U P P E R                   */
  1424. /*    We need toupper implemented as a function.        */
  1425. /*------------------------------------------------------*/
  1426. our_toupper(value)
  1427. int value;
  1428. {
  1429.    if (isascii(value) && isalpha(value) && islower(value))
  1430.       return(toupper(value) & 0xFF);
  1431.    return(value & 0xFF);
  1432. }
  1433.  
  1434. /*------------------------------------------------------*/
  1435. /*                P R O C E S S _ A T T R             */
  1436. /*     This routine is a pre-processor for exe_attr     */
  1437. /*     that reads from 'indoc' and resolves all    */
  1438. /*     references, possibly deleting leading and   */
  1439. /*     trailing spaces, then placing the resulting */
  1440. /*     string in 'buffer'.          */
  1441. /*------------------------------------------------------*/
  1442. process_attr(buffer,delim,genthead,dvcode,num_csdata)
  1443. char buffer[];
  1444. int delim;
  1445. ENTITYDESC *genthead;
  1446. DECLVAL dvcode;
  1447. unsigned *num_csdata;
  1448. {
  1449.    int inchar,indx,charnum,actual_length,inter_length;
  1450.    char entname[NAMELEN+1],number[NAMELEN+1];
  1451.    ENTITYDESC *entptr;
  1452.    BOOLEAN datatext_read;
  1453.  
  1454.    if (dvcode != ENUM_CDATA)
  1455.       actual_length = gettilnosep();
  1456.  
  1457.    datatext_read = FALSE;
  1458.    actual_length = indx = *num_csdata = 0;
  1459.  
  1460.    while((inchar=our_fgetc(indoc))!=delim || entitylevel>0)
  1461.       if (inchar==ERO && !datatext_read)
  1462.          if (isalpha(inchar=our_fgetc(indoc))) {
  1463.             our_ungetc(inchar,indoc);
  1464.             inter_length = get_entname(entname,nullfnc);
  1465.             if (entitylevel == 0)
  1466.                actual_length += inter_length+1;  /* includes the '&' */
  1467.  
  1468.             if ((entptr=find_entity(genthead,entname,TRUE)) == NULL) {
  1469.                sprintf(error_msg,"%s%s%s","\nError: Unknown general entity name '",entname,"'.\n");
  1470.                FATAL_ERROR()
  1471.             }
  1472.             else
  1473.                check_entity(dvcode==ENUM_CDATA,num_csdata,entptr,&datatext_read,entname,&actual_length,TRUE,&inchar);
  1474.          }
  1475.          else
  1476.             if (inchar == '#')
  1477.                if (isalpha(inchar=our_fgetc(indoc))) {
  1478.                   our_ungetc(inchar,indoc);
  1479.                   inter_length = get_entname(entname,our_toupper);
  1480.                   if (entitylevel == 0)
  1481.                      actual_length += inter_length+2;
  1482.                   if (strcmp(entname,"TAB") == 0)
  1483.                      buffer[indx++] = SEPCHAR;
  1484.                   else
  1485.                      if (strcmp(entname,"RS") == 0)
  1486.                         buffer[indx++] = RS;
  1487.                      else
  1488.                         if (strcmp(entname,"RE") == 0)
  1489.                            buffer[indx++] = RE;
  1490.                         else
  1491.                            if (strcmp(entname,"SPACE") == 0)
  1492.                               buffer[indx++] = SPACE;
  1493.                            else {
  1494.                               sprintf(error_msg,"%s%s%s","\nError: Unknown character reference '",entname,"'.\n");
  1495.                               FATAL_ERROR()
  1496.                            }
  1497.                   if ((inchar=our_fgetc(indoc)) != REFC)
  1498.                      our_ungetc(inchar,indoc);
  1499.                   else
  1500.                      actual_length++;
  1501.                }
  1502.                else
  1503.                   if (isdigit(inchar)) {
  1504.                      our_ungetc(inchar,indoc);
  1505.                      inter_length = get_number(number,nullfnc);
  1506.                      if (entitylevel == 0)
  1507.                         actual_length += inter_length+2;
  1508.                      CLEAR_BUF();  /* don't want number printed out */
  1509.  
  1510.                      charnum = atoi(number);
  1511.                      if ((charnum<CHARSET_LOWBOUND) || (charnum>CHARSET_HIGHBOUND))
  1512.                         ourexit(2,"\nError: Invalid character reference number\n");
  1513.                      else
  1514.                         buffer[indx++] = charnum;
  1515.                      if ((inchar=our_fgetc(indoc)) != REFC)
  1516.                         our_ungetc(inchar,indoc);
  1517.                      else
  1518.                         actual_length++;
  1519.                   }
  1520.                   else {
  1521.                      buffer[indx++] = ERO;
  1522.                      buffer[indx++] = '#';
  1523.                      buffer[indx++] = inchar;
  1524.                   }
  1525.             else {
  1526.                buffer[indx++] = ERO;
  1527.                buffer[indx++] = inchar;
  1528.             }
  1529.       else {
  1530.          if (entitylevel == 0)
  1531.             actual_length++;
  1532.          switch(inchar) {
  1533.          case RS:
  1534.             break;
  1535.          case OUR_EE:
  1536.             entitylevel--;
  1537.             datatext_read = FALSE;
  1538.             break;
  1539.          case RE:  
  1540.          case SEPCHAR:
  1541.             buffer[indx++] = SPACE;
  1542.             break;
  1543.          default:
  1544.             buffer[indx++] = inchar;
  1545.             break;
  1546.          }
  1547.       }
  1548.    our_ungetc(inchar,indoc);
  1549.    if (dvcode != ENUM_CDATA) {  /* will strip trailing seps from    */
  1550.                                 /* 'buffer' by decrementing 'indx'. */
  1551.       while(SEPERATOR(buffer[indx]))
  1552.          indx--;
  1553.       indx++;
  1554.    }
  1555.    buffer[indx] = '\0';
  1556.    return(actual_length);
  1557. }
  1558.  
  1559. /*------------------------------------------------------*/
  1560. /*                 T R Y _ E N T R E F                  */
  1561. /* This routine process general entity references, */
  1562. /* named character references, and numeric   char- */
  1563. /* acter references if they exist.        */
  1564. /*------------------------------------------------------*/
  1565. void try_entref(inchar,genthead,save_char,try_ft)
  1566. int inchar;
  1567. ENTITYDESC *genthead;
  1568. BOOLEAN save_char,*try_ft;
  1569. {
  1570.    register int charnum;
  1571.    ENTITYDESC *entptr;
  1572.    char entname[NAMELEN+1],
  1573.         number[NAMELEN+1],
  1574.         *outstr;
  1575.    static BOOLEAN datatext_read=FALSE;
  1576.  
  1577.    *try_ft = FALSE;
  1578.    outstr = get_char_mem(2);
  1579.    number[NAMELEN+1] = '\0';
  1580.    if (inchar==ERO && !datatext_read)
  1581.       /*  Found a general entity reference */
  1582.       if (isalpha(inchar=our_fgetc(indoc))) {
  1583.          our_ungetc(inchar,indoc);
  1584.          get_entname(entname,nullfnc);
  1585.          if ((entptr=find_entity(genthead,entname,TRUE)) == NULL) {
  1586.             sprintf(error_msg,"%s%s%s","\nError: Unknown general entity name '",entname,"'.\n");
  1587.             FATAL_ERROR()
  1588.          }
  1589.          else
  1590.             check_entity(TRUE,(unsigned int *) 0,entptr,&datatext_read,
  1591.                                             entname,(int *) 0,FALSE,&inchar);
  1592.       }
  1593.       else
  1594.          if (inchar == '#')
  1595.             /* Found a named character reference */
  1596.             if (isalpha(inchar=our_fgetc(indoc))) {
  1597.                our_ungetc(inchar,indoc);
  1598.                get_entname(entname,our_toupper);
  1599.                if (strcmp(entname,"TAB") == 0) {
  1600.                   (*put_ctr)(SEPCHAR,ctrfp);
  1601.                   *outstr = SEPCHAR;
  1602.                   (*applic)(DATA_STG,outstr,"");
  1603.                }
  1604.                else
  1605.                   if (strcmp(entname,"RS") == 0) {
  1606.                      (*put_ctr)(RS,ctrfp);
  1607.                      *outstr = RS;
  1608.                      (*applic)(DATA_STG,outstr,"");
  1609.                   }
  1610.                   else
  1611.                      if (strcmp(entname,"RE") == 0) {
  1612.                         (*put_ctr)(RE,ctrfp);
  1613.                         *outstr = RE;
  1614.                         (*applic)(DATA_STG,outstr,"");
  1615.                      }
  1616.                      else
  1617.                         if (strcmp(entname,"SPACE") == 0) {
  1618.                            (*put_ctr)(SPACE,ctrfp);
  1619.                            *outstr = SPACE;
  1620.                            (*applic)(DATA_STG,outstr,"");
  1621.                         }
  1622.                         else {
  1623.                            sprintf(error_msg,"%s%s%s","\nError: Invalid named character reference '",entname,"'.\n");
  1624.                            FATAL_ERROR()
  1625.                         }
  1626.  
  1627.                if ((inchar=our_fgetc(indoc)) != REFC)
  1628.                   if (inchar == RE)  /* RS and RE are insignificant */
  1629.                      inchar = our_fgetc(indoc);  /* get RS */
  1630.                   else
  1631.                      our_ungetc(inchar,indoc);
  1632.  
  1633.             }
  1634.             else
  1635.                /* Found a numeric character reference */
  1636.                if (isdigit(inchar)) {
  1637.                   our_ungetc(inchar,indoc);
  1638.                   get_number(number,nullfnc);
  1639.                   CLEAR_BUF();  /* don't want number printed out */
  1640.                   charnum = atoi(number);
  1641.                   if ((charnum<CHARSET_LOWBOUND) || (charnum>CHARSET_HIGHBOUND)) {
  1642.                      sprintf(error_msg,"%s%s%s","\nError: Invalid numeric character reference '",number,"'.\n");
  1643.                      FATAL_ERROR()
  1644.                   }
  1645.                   else
  1646.                      if (!SGMLCHAR(charnum)) {
  1647.                         (*print_ctr)(ctrfp,"\n[#%d]",charnum);
  1648.                         *try_ft = TRUE;
  1649.                      }
  1650.                      else
  1651.                         (*put_ctr)(charnum,ctrfp);
  1652.                   *outstr = charnum;
  1653.                   (*applic)(DATA_STG,outstr,"");
  1654.                   if ((inchar=our_fgetc(indoc)) != REFC) {
  1655.                      if (inchar == RE)  /* RS and RE are insignificant */
  1656.                         inchar = our_fgetc(indoc);  /* get RS */
  1657.                      else
  1658.                         our_ungetc(inchar,indoc);
  1659.                   }
  1660.                }
  1661.                else {
  1662.                   our_ungetc(inchar,indoc);
  1663.                   (*print_ctr)(ctrfp,"%c#",ERO);
  1664.                   *outstr = ERO;
  1665.                   (*applic)(DATA_STG,outstr,""); 
  1666.                   (*applic)(DATA_STG,"#","");
  1667.                }
  1668.          else {
  1669.             our_ungetc(inchar,indoc);
  1670.             (*print_ctr)(ctrfp,"%c",ERO);
  1671.             *outstr = ERO;
  1672.             (*applic)(DATA_STG,outstr,"");
  1673.          }
  1674.    else
  1675.       if (inchar == OUR_EE) {
  1676.          datatext_read = FALSE;
  1677.          entitylevel--;
  1678.       }
  1679.       else
  1680.          if (save_char)
  1681.             our_ungetc(inchar,indoc);
  1682.          else
  1683.             if (inchar != EOF) {
  1684.                (*put_ctr)(inchar,ctrfp);
  1685.                *outstr = inchar;
  1686.                (*applic)(DATA_STG,outstr,"");
  1687.             }
  1688.    free(outstr);
  1689.    return;
  1690. }
  1691.  
  1692. /*------------------------------------------------------*/
  1693. /*                R E S O L V E _ A T T R               */
  1694. /* This routine resolves the defaults that were */
  1695. /* not explicitly specified in the attribute */
  1696. /* specifications.  The defaults are outputted  */
  1697. /* to 'outdoc' and IDs and IDREFs are added to  */
  1698. /* their appropriate linked lists.        */
  1699. /*------------------------------------------------------*/
  1700. resolve_attr(headadp,print_to_file)
  1701. ATTRDESC *headadp;
  1702. int print_to_file;
  1703. {
  1704.    char outvalue[LITLEN+1];  /* allow for null terms */
  1705.    char buffer[NAMELEN+1];
  1706.    register int i,j;
  1707.    unsigned num_id_idref;
  1708.    BOOLEAN more_def_desc;
  1709.    ATTRDESC *thisadp;
  1710.  
  1711.    num_id_idref = 0;
  1712.    for (thisadp=headadp; thisadp!=NULL; thisadp=thisadp->next) {
  1713.       if (print_to_file == FALSE)
  1714.          putstr_outbuf("\n ");
  1715.       else
  1716.          (*print_ctr)(ctrfp,"\n ");
  1717.       if ((thisadp->defcode==A_IMPLIED||thisadp->defcode==A_CONREF) &&
  1718.           thisadp->processed==FALSE) {
  1719.          if (print_to_file == FALSE) {
  1720.             putchar_outbuf(' '); 
  1721.             putstr_outbuf(thisadp->attrname);
  1722.             putstr_outbuf("=#IMPLIED");
  1723.             place_in_queue(TAG_ATTR,thisadp->attrname,"");
  1724.          }
  1725.          else {
  1726.             if (thisadp->dvcode==ID||thisadp->dvcode==IDREF||thisadp->dvcode==IDREFS)
  1727.                num_id_idref++;
  1728.             (*print_ctr)(ctrfp," %s=#IMPLIED",thisadp->attrname);
  1729.             (*applic)(TAG_ATTR,thisadp->attrname,"");
  1730.          }
  1731.       }
  1732.       else {
  1733.          if (thisadp->dvcode==GROUP || thisadp->dvcode==NOTATION)
  1734.             strcpy(outvalue,thisadp->u2.currgrp->groupname);
  1735.          else        
  1736.              strcpy(outvalue,thisadp->u2.currdef);
  1737.          switch(thisadp->defcode) {
  1738.          case A_CURRENT:   /* if current and IDREF, already in list */
  1739.             if (thisadp->dvcode == ID) {
  1740.                sprintf(error_msg,"%s%s'.\n","\nError: ID values not unique after default resolution '",thisadp->attrname);
  1741.                FATAL_ERROR()
  1742.             }
  1743.             if (thisadp->dvcode==IDREF || thisadp->dvcode==IDREFS)
  1744.                num_id_idref++;
  1745.             break;
  1746.          case A_UNFIXED:  
  1747.          case A_FIXED:
  1748.          case A_REQD:     
  1749.          case A_IMPLIED: 
  1750.          case A_CONREF:
  1751.             if (thisadp->dvcode==ID || thisadp->dvcode==IDREF) {
  1752.                num_id_idref++;
  1753. #ifdef OLD
  1754.                memset(buffer,'\0',NAMELEN+1);
  1755. #else
  1756.                memset(buffer,'\0',sizeof(buffer));
  1757. #endif
  1758.                for (i=0; i<strlen(outvalue) && i<NAMELEN; i++)
  1759.                   buffer[i] = outvalue[i];
  1760. #ifdef OLD
  1761.                if (i >= NAMELEN)
  1762.                   ourexit(2,"\nError: ID-IDREF name violates NAMELEN quantity\n");
  1763. #else
  1764.                if (strlen(buffer) > NAMELEN)
  1765.                   ourexit(2,"\nError: ID-IDREF name violates NAMELEN quantity\n");
  1766. #endif
  1767.                if (thisadp->dvcode == ID)
  1768.                   insert(&idhead,buffer,thisadp->dvcode);
  1769.                else
  1770.                   insert(&idrefhead,buffer,thisadp->dvcode);
  1771.             }
  1772.             else
  1773.                if (thisadp->dvcode == IDREFS) {
  1774.                   more_def_desc = TRUE;
  1775.                   i = 0;
  1776.                   while(more_def_desc) {
  1777.                      num_id_idref++;
  1778.                      while(thisadp->u2.currdef[i] == ' ')
  1779.                         i++;
  1780.                      memset(buffer,'\0',NAMELEN+1);
  1781.                      j = 0;
  1782.                      while(!(SEPERATOR(thisadp->u2.currdef[i])) && thisadp->u2.currdef[i]!='\0') {
  1783.                         buffer[j] = thisadp->u2.currdef[i]; 
  1784.                         i++;  j++;
  1785.                      }
  1786.                      insert(&idrefhead,buffer,thisadp->dvcode);
  1787.                      more_def_desc = (thisadp->u2.currdef[i] != '\0');
  1788.                   }
  1789.                }
  1790.             break;
  1791.          }
  1792.          if (print_to_file == FALSE) {
  1793.             putchar_outbuf(' '); 
  1794.             putstr_outbuf(thisadp->attrname);    
  1795.             putstr_outbuf("=\"");
  1796.             output_with_lb(strlen(thisadp->attrname)+3,outvalue,FALSE);
  1797.             putstr_outbuf("\"");
  1798.             place_in_queue(TAG_ATTR,thisadp->attrname,outvalue);
  1799.          }
  1800.          else {
  1801.             if (thisadp->dvcode==ID||thisadp->dvcode==IDREF||thisadp->dvcode==IDREFS)
  1802.                num_id_idref++;
  1803.             (*print_ctr)(ctrfp," %s=\"",thisadp->attrname);
  1804.             output_with_lb(strlen(thisadp->attrname)+3,outvalue,TRUE);
  1805.             (*print_ctr)(ctrfp,"\"");
  1806.             (*applic)(TAG_ATTR,thisadp->attrname,outvalue);
  1807.          }
  1808.       }
  1809.    }
  1810.    return(num_id_idref);
  1811. }
  1812.  
  1813. /*--------------------------------------------------------------*/
  1814. /*             O U T P U T _ W I T H _ L B                      */
  1815. /* The CTR requires that output of data or attribute  */
  1816. /* values exceeding a column position (nominally 60)  */
  1817. /* be broken into multiple lines with a line-break    */
  1818. /* character placed at the end of each line.    */
  1819. /*--------------------------------------------------------------*/
  1820. void output_with_lb(currcol,outstr,print_to_file)
  1821. int currcol;
  1822. char *outstr;
  1823. BOOLEAN print_to_file;
  1824. {
  1825.    char *cptr,buffer[13];
  1826.  
  1827.    for (cptr=outstr; *cptr != '\0'; cptr++)
  1828.       if (++currcol > MAXCOL) {
  1829.          if (print_to_file)
  1830.             if (SGMLCHAR(*cptr))
  1831.                (*print_ctr)(ctrfp,"|\n%c",*cptr);
  1832.             else
  1833.                (*print_ctr)(ctrfp,"|\n[#%d]",*cptr);
  1834.          else {
  1835.             if (SGMLCHAR(*cptr)) {
  1836.                putstr_outbuf("|\n");
  1837.                putchar_outbuf(*cptr);
  1838.             }
  1839.             else {
  1840.                sprintf(buffer,"|\n[#%d]",*cptr);
  1841.                putstr_outbuf(buffer);
  1842.             }
  1843.          }
  1844.          currcol = 0;
  1845.       }
  1846.       else
  1847.          if (print_to_file)
  1848.             if (SGMLCHAR(*cptr))
  1849.                (*print_ctr)(ctrfp,"%c",*cptr);
  1850.             else
  1851.                (*print_ctr)(ctrfp,"\n[#%d]",*cptr);
  1852.          else
  1853.             if (SGMLCHAR(*cptr))
  1854.                putchar_outbuf(*cptr);
  1855.             else {
  1856.                sprintf(buffer,"\n[#%d]",*cptr);
  1857.                putstr_outbuf(buffer);
  1858.             }
  1859.    return;
  1860. }
  1861.  
  1862. /*------------------------------------------------------*/
  1863. /*       F I L L U P          */
  1864. /* Used to fill up the rest of name, nmtoken,   */
  1865. /* or nutoken array.  Input is taken from the   */
  1866. /* input document and the same restrictions  */
  1867. /* apply here in terms of NAMELEN.        */
  1868. /*------------------------------------------------------*/
  1869. void fillup(string,indx,capitalize)
  1870. char string[];
  1871. int *indx;
  1872. int (*capitalize)();
  1873. {
  1874.    int inchar;
  1875.    inchar = our_fgetc(indoc);
  1876.    while(NAMECHAR(inchar) && *indx<=NAMELEN) {
  1877.       string[*indx] = (*capitalize)(inchar);  /* case insensitive */
  1878.       putchar_outbuf(string[(*indx)++]);
  1879.       inchar = our_fgetc(indoc);
  1880.    }
  1881.    our_ungetc(inchar,indoc);
  1882.    return;
  1883. }
  1884.  
  1885. /*------------------------------------------------------*/
  1886. /*------------------------------------------------------*/
  1887. /*------------------------------------------------------*/
  1888. void fillup2(string,indx,capitalize)
  1889. char string[];
  1890. int *indx;
  1891. int (*capitalize)();
  1892. {
  1893.    int inchar;
  1894.    inchar = our_fgetc(indoc);
  1895.    while(NAMECHAR(inchar) && *indx<=NAMELEN) {
  1896.       string[*indx] = (*capitalize)(inchar);  /* case insensitive */
  1897.       (*indx)++;
  1898.       inchar = our_fgetc(indoc);
  1899.    }
  1900.    our_ungetc(inchar,indoc);
  1901.    return;
  1902. }
  1903.